﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Text;
using SIPDTO;
using SIPDAL;

namespace SIPBLL
{
    // NOTE: You can use the "Rename" command on the "Refactor" menu to change the class name "SIPBLL" in both code and config file together.
    public class SIPBLL : ISIPBLL
    {
        public void DoWork()
        {
        }
        /// <summary>
        /// Metodos para la clase mgParroquia
        /// </summary>
        /// <param name="parroquia"></param>
        /// <returns></returns>
        public dtoError AceptarParroquia(dtoParroquia parroquia, int evento)
        {
            dtoError resp = new dtoError();
            mgParroquia  mparroquia = new mgParroquia();
            resp = mparroquia.AceptarParroquia(parroquia, evento);
            return resp;

        }
        public dtoError InactivarParroquia(dtoParroquia parroquia)
        {
            dtoError resp = new dtoError();
            mgParroquia mparroquia = new mgParroquia();
            resp = mparroquia.InactivarParroquia(parroquia);
            return resp;

        }

        public List<dtoParroquia> ObtenerTodasParroquia()
        {
            List<dtoParroquia> reg = new List<dtoParroquia>();
            mgParroquia mparroquia = new mgParroquia();
            reg = mparroquia.ObtenerTodasParroquias();
            return reg;

        }
        public List<dtoParroquia> ObtenerParroquiaxDiocesis(dtoParroquia parroquia)
        {
            List<dtoParroquia> reg = new List<dtoParroquia>();
            mgParroquia mparroquia = new mgParroquia();
            reg = mparroquia.ObtenerParroquiaxDiocesis(parroquia);
            return reg;

        }
        public List<dtoParroquia> ObtenerParroquia(int _valor)
        {
            List<dtoParroquia> reg = new List<dtoParroquia>();
            mgParroquia mparroquia = new mgParroquia();
            reg = mparroquia.ObtenerParroquias( _valor);
            return reg;

        }

        /// <summary>
        /// Metodos para la clase mgProvincia
        /// </summary>
        /// <param name="provincia"></param>
        /// <returns></returns>
        public dtoError AceptarProvincia(dtoProvincias provincia,int evento)
        {
            dtoError resp = new dtoError();
            mgProvincia mprovincia = new mgProvincia();
            resp = mprovincia.AceptarProvincia(provincia, evento);
            return resp;

        }

        public List<dtoProvincias> ObtenerProvincia()
        {
            List<dtoProvincias> reg = new List<dtoProvincias>();
            mgProvincia provincia = new mgProvincia();
            reg = provincia.ObtenerProvincia();
            return reg;
        }

        public List<dtoProvincias> ObtenerProvincia(dtoProvincias provincia)
        {
            List<dtoProvincias> reg = new List<dtoProvincias>();
            mgProvincia mprovincia = new mgProvincia();
            reg = mprovincia.ObtenerProvincia(provincia);
            return reg;
        }
        public dtoError InactivarProvincia(dtoProvincias provincia)
        {
            dtoError resp = new dtoError();
            mgProvincia mprovincia = new mgProvincia();
            resp = mprovincia.InactivarProvincia(provincia);
            return resp;
        }
        
        /// <summary>
        /// Metodos para la clase mgCanton
        /// </summary>
        /// <param name="canton"></param>
        /// <returns></returns>
        public dtoError AceptarCanton(dtoCanton canton, int evento)
        {
            dtoError resp = new dtoError();
            mgCanton mcanton = new mgCanton();
            resp = mcanton.AceptarCanton(canton, evento);
            return resp;

        }

        public List<dtoCanton> ObtenerCanton(dtoCanton canton)
        {
            List<dtoCanton> reg = new List<dtoCanton>();
            mgCanton mcanton = new mgCanton();
            reg = mcanton.ObtenerCanton(canton);
            return reg;

        }
        public List<dtoCanton> ObtenerCantonxProvincia(dtoCanton canton)
        {
            List<dtoCanton> reg = new List<dtoCanton>();
            mgCanton mcanton = new mgCanton();
            reg = mcanton.ObtenerCantonxProvincia(canton);
            return reg;

        }
        public List<dtoCanton> ObtenerTodosCantones()
        {
            List<dtoCanton> reg = new List<dtoCanton>();
            mgCanton mcanton = new mgCanton();
            reg = mcanton.ObtenerTodosCantones();
            return reg;

        }
        public dtoError InactivarCanton(dtoCanton canton)
        {
            dtoError resp = new dtoError();
            mgCanton mcanton = new mgCanton();
            resp = mcanton.InactivarCanton(canton);
            return resp;
        }

        /// <summary>
        /// Metodos para la clase mgDistritos
        /// </summary>
        /// <param name="distrito"></param>
        /// <returns></returns>
        public dtoError AceptarDistrito(dtoDistrito distrito, int evento)
        {
            dtoError resp = new dtoError();
            mgDistrito mdistrito = new mgDistrito();
            resp = mdistrito.AceptarDistrito(distrito, evento);
            return resp;

        }

        public List<dtoDistrito> ObtenerDistrito()
        {
            List<dtoDistrito> reg = new List<dtoDistrito>();
            mgDistrito mdistrito = new mgDistrito();
            reg = mdistrito.ObtenerDistrito();
            return reg;
        }

        public List<dtoDistrito> ObtenerDistrito(dtoDistrito  distrito)
        {
            List<dtoDistrito> reg = new List<dtoDistrito>();
            mgDistrito mdistrito = new mgDistrito();
            reg = mdistrito.ObtenerDistrito(distrito);
            return reg;
        }

        public dtoError InactivarDistrito(dtoDistrito distrito)
        {
            dtoError resp = new dtoError();
            mgDistrito mdistrito = new mgDistrito();
            resp = mdistrito.InactivarDistrito(distrito);
            return resp;
        }

        /// <summary>
        /// Metodos para la clase mgDiocesis
        /// </summary>
        /// <returns></returns>
        public dtoError AceptarDiocesis(dtoDiocesis diocesis, int evento)
        {
            dtoError resp = new dtoError();
            mgDiocesis mdiocesis = new mgDiocesis();
            resp = mdiocesis.AceptarDiocesis(diocesis, evento);
            return resp;

        }

        public List<dtoDiocesis> ObtenerTodasDiocesis()
        {
            List<dtoDiocesis> reg = new List<dtoDiocesis>();
            mgDiocesis mdiocesis = new mgDiocesis();
            reg = mdiocesis.ObtenerTodasDiocesis();
            return reg;

        }

        public List<dtoDiocesis> ObtenerDiocesis()// metodo para cargar el combo
        {
            List<dtoDiocesis> reg = new List<dtoDiocesis>();
            mgDiocesis mdiocesis = new mgDiocesis();
            reg = mdiocesis.ObtenerDiocesis();
            return reg;

        }
        public List<dtoDiocesis> ObtenerDiocesis(dtoDiocesis diocesis)
        {
            List<dtoDiocesis> reg = new List<dtoDiocesis>();
            mgDiocesis mdiocesis = new mgDiocesis();
            reg = mdiocesis.ObtenerDiocesis(diocesis);
            return reg;

        }

        public dtoError InactivarDiocesis(dtoDiocesis diocesis)
        {
            dtoError resp = new dtoError();
            mgDiocesis mdiocesis = new mgDiocesis();
            resp = mdiocesis.InactivarDiocesis(diocesis);
            return resp;
        }

        /// <summary>
        ///Metodos para la clase mgUsuario
        /// </summary>
        public dtoError CrearUsuario(dtoUsuario func, int evento)
        {
            dtoError resp = new dtoError();
            mgUsuario usuario = new mgUsuario();
            resp = usuario.Crear_Usuario(func, evento);
            return resp;
        }

        public List<dtoUsuario> ObtenerTodosUsuarios()
        {
            List<dtoUsuario> reg = new List<dtoUsuario>();
            mgUsuario usuario = new mgUsuario();
            reg = usuario.ObtenerTodosUsuarios();
            return reg;

        }

        public List<dtoUsuario> ObtenerUsuario(dtoUsuario dtusuario)
        {
            List<dtoUsuario> reg = new List<dtoUsuario>();
            mgUsuario usuario = new mgUsuario();
            reg = usuario.ObtenerUsuario(dtusuario);
            return reg;
        }

        public dtoError InactivarUsuario(dtoUsuario dtusuario)
        {
            dtoError resp = new dtoError();
            mgUsuario mdiocesis = new mgUsuario();
            resp = mdiocesis.InactivarUsuario(dtusuario);
            return resp;
        }





        /// <summary>
        /// Metodo para la clase mgPersonas
        /// </summary>
        /// <param name="personas"></param>
        /// <returns></returns>

        public dtoError RegistrarPersonas(dtoPersonas personas, int evento)
        {
            dtoError resp = new dtoError();
            mgPersonas persona = new mgPersonas();
            resp = persona.Registrar_Persona(personas,evento);
            return resp;

        }
        public List<dtoPersonas> ObtenerPersona(dtoPersonas personas)
        {
            List<dtoPersonas> reg = new List<dtoPersonas>();
            mgPersonas parametro = new mgPersonas();
            reg = parametro.ObtenerPersona(personas);
            return reg;

        }
        public List<dtoPersonas> ObtenerTodasPersona()
        {
            List<dtoPersonas> reg = new List<dtoPersonas>();
            mgPersonas parametro = new mgPersonas();
            reg = parametro.ObtenerTodasPersonas();
            return reg;

        }

        public dtoError Existe_Persona(dtoPersonas persona)
        {
            dtoError _dtoerror = new dtoError();
            mgPersonas parametro = new mgPersonas();
            _dtoerror = parametro.Existe_Persona(persona);

            return _dtoerror;
        }

        public dtoError ValidarUsuario(dtoUsuario func)
        {
            dtoError resp = new dtoError();
            mgUsuario usuario = new mgUsuario();
            resp = usuario.Validar_Usuario(func);
            return resp;
        }



        public dtoError RegistrarParametro(dtoParametros vparametro, int evento)
        {
            dtoError resp = new dtoError();
            mgParametros  parametro = new mgParametros() ;
            resp = parametro.AceptarParametro(vparametro, evento);
            return resp;
        }

        public List<dtoParametros> ObtenerParametro(string valparametro)
        {
            List<dtoParametros> reg = new List<dtoParametros>();
            mgParametros parametro = new mgParametros();
            reg = parametro.ObtenerParametro(valparametro);
            return reg;
        }

        public dtoError RegistrarParametroBautizo(dtoParametros vparametro)
        {
            dtoError resp = new dtoError();
            mgParametros parametro = new mgParametros();
            resp = parametro.RegistraParametroBautizo(vparametro);
            return resp;
        }

        public List<dtoParametros> ObtenerParametroBautizo(string valparametro, int parroquia)
        {
            List<dtoParametros> reg = new List<dtoParametros>();
            mgParametros parametro = new mgParametros();
            reg = parametro.ObtenerParametroBautizos(valparametro, parroquia);
            return reg;
        }

        public dtoError RegistrarParametroConfirma(dtoParametros vparametro)
        {
            dtoError resp = new dtoError();
            mgParametros parametro = new mgParametros();
            resp = parametro.RegistraParametroConfirma(vparametro);
            return resp;
        }
        public List<dtoParametros> ObtenerParametroConfirma(string valparametro, int parroquia)
        {
            List<dtoParametros> reg = new List<dtoParametros>();
            mgParametros parametro = new mgParametros();
            reg = parametro.ObtenerParametroConfirma(valparametro, parroquia);
            return reg;
        }

        public dtoError RegistrarParametroMatrimonio(dtoParametros vparametro)
        {
            dtoError resp = new dtoError();
            mgParametros parametro = new mgParametros();
            resp = parametro.RegistraParametroMatrimonio(vparametro);
            return resp;
        }
        public List<dtoParametros> ObtenerParametroMatrimonio(string valparametro, int parroquia)
        {
            List<dtoParametros> reg = new List<dtoParametros>();
            mgParametros parametro = new mgParametros();
            reg = parametro.ObtenerParametroMatrimonio(valparametro, parroquia);
            return reg;
        }

        public List<dtoCargo> ObtenerCargo()
        {
            List<dtoCargo> reg = new List<dtoCargo>();
            mgCargo cargo = new mgCargo();
            reg = cargo.ObtenerCargos();
            return reg;
        }

        public List<dtoPerfil> ObtenerPerfil()
        {
            List<dtoPerfil> reg = new List<dtoPerfil>();
            mgPerfil cargo = new mgPerfil();
            reg = cargo.ObtenerPerfiles();
            return reg;
        }

        public List<dtoTiposIdentificacion> ObtenerTiposId()
        {
            List<dtoTiposIdentificacion> reg = new List<dtoTiposIdentificacion>();
            mgTipoIdentificacion tiposid = new mgTipoIdentificacion();
            reg = tiposid.ObtenerTipos();
            return reg;
        }


        /// <summary>
        /// Metodo para la clase mClerigo
        /// </summary>
        /// <param name="clerigo"></param>
        /// <returns></returns>
        public dtoError RegistrarClerigo(dtoClerigo clerigo, int evento)
       {
           dtoError resp = new dtoError();
           mgClerigo persona = new mgClerigo();
           resp = persona.RegistrarClerigo(clerigo, evento);
           return resp;

       }

       public List<dtoClerigo> ObtenerClerigo(dtoClerigo clerigo)
       {
           List<dtoClerigo> reg = new List<dtoClerigo>();
           mgClerigo parametro = new mgClerigo();
           reg = parametro.ObtenerClerigo(clerigo);
           return reg;

       }

       public List<dtoClerigo> ObtenerClerigoxParroquia(dtoClerigo clerigo)
       {
           List<dtoClerigo> reg = new List<dtoClerigo>();
           mgClerigo parametro = new mgClerigo();
           reg = parametro.ObtenerClerigoxParroquia(clerigo);
           return reg;

       }

       public List<dtoClerigo> ObtenerClerigoxParroquia(int parroquia)
       {
           List<dtoClerigo> reg = new List<dtoClerigo>();
           mgClerigo parametro = new mgClerigo();
           reg = parametro.ObtenerClerigoxParroquia(parroquia);
           return reg;

       }

       public List<dtoClerigo> ObtenerTodosClerigo()
       {
           List<dtoClerigo> reg = new List<dtoClerigo>();
           mgClerigo parametro = new mgClerigo();
           reg = parametro.ObtenerTodosClerigo();
           return reg;

       }

       public dtoError InactivarClerigo(dtoClerigo clerigo)
       {
           dtoError resp = new dtoError();
           mgClerigo parametro = new mgClerigo();
           resp = parametro.InactivarClerigo(clerigo);
           return resp;

       }

       /// <summary>
       /// Metodo para la clase mgConfirma
       /// </summary>
       /// <param name="clerigo"></param>
       /// <returns></returns>
       public dtoError RegistrarConfirma(dtoConfirma dtconfirma)
       {
           dtoError resp = new dtoError();
           mgConfirma confirma = new mgConfirma();
           resp = confirma.RegistrarConfirma(dtconfirma);
           return resp;

       }

       public List<dtoConfirma> ObtenerConfirmaxParroquia(dtoConfirma dtconfirma)
       {
           List<dtoConfirma> reg = new List<dtoConfirma>();
           mgConfirma parametro = new mgConfirma();
           reg = parametro.ObtenerConfirmaxParroquia(dtconfirma);
           return reg;
       }

    /// <summary>
    /// Bautizos
    /// </summary>
    /// <param name="dtmatrimonio"></param>
    /// <returns></returns>
       public dtoError RegistrarBautizos(dtoBautizos  dtbautizos)
       {
           dtoError resp = new dtoError();
           mgBautizo bautizo = new mgBautizo();
           resp = bautizo.RegistrarBautizo(dtbautizos);
           return resp;

       }
        /// <summary>
        /// obtiene la información de las constancias de bautizo por parroquia
        /// </summary>
        /// <param name="bautizos"></param>
        /// <returns></returns>
       public List<dtoBautizos > ObtenerBautizosxParroquia(dtoBautizos bautizos)
       {
           List<dtoBautizos > reg = new List<dtoBautizos >();
           mgBautizo parametro = new mgBautizo();
           reg = parametro.ObtenerBautizosxParroquia(bautizos);
           return reg;

       }

       /// <summary>
       /// Metodo para la clase mgMatrimonio
       /// </summary>
       /// <param name="clerigo"></param>
       /// <returns></returns>
       public dtoError RegistrarMatrimonio(dtoMatrimonio  dtmatrimonio)
       {
           dtoError resp = new dtoError();
           mgMatrimonio matrimonio = new mgMatrimonio();
           resp = matrimonio.RegistrarMatrimonio(dtmatrimonio);
           return resp;

       }

       public List<dtoMatrimonio> ObtenerMatrimonioxParroquia(dtoMatrimonio matrimonio)
       {
           List<dtoMatrimonio> reg = new List<dtoMatrimonio>();
           mgMatrimonio parametro = new mgMatrimonio();
           reg = parametro.ObtenerMatrimonioxParroquia(matrimonio);
           return reg;
       }
    }
}
